Qual è l'operatore "->" in C ++?

-> non è un operatore. Sono infatti due operatori separati, - e>.
Il codice condizionale decrementa x, restituendo il valore originale (non decrementato) di x, quindi confronta il valore originale con 0 utilizzando l'operatore>.
Per capire meglio, la dichiarazione potrebbe essere scritta come segue:
mentre ((x--)> 0)
|
O per qualcosa di completamente diverso ... x scorre a 0.
while (x - \
\
\
\
> 0)
printf ("% d", x);
Non così matematico, ma ... ogni immagine dipinge più di mille parole ...
|
Questo è un operatore molto complicato, quindi anche ISO / IEC JTC1 (Joint Technical Committee 1) ha inserito la sua descrizione in due parti diverse dello standard C ++.
A parte gli scherzi, sono due diversi operatori: - e> descritti rispettivamente in §5.2.6 / 2 e §5.9 dello Standard C ++ 03.
|
È equivalente a
mentre (x--> 0)
x-- (post decremento) è equivalente a x = x-1 quindi, il codice si trasforma in:
while (x> 0) {
x = x-1;
// logica
}
X--; // Il decremento del post eseguito quando x <= 0
|
x può andare a zero ancora più velocemente nella direzione opposta:
int x = 10;
while (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Puoi controllare la velocità con una freccia!
int x = 100;
mentre (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Suo
#include 
int main (void) {
int x = 10;
while (x--> 0) {// x va a 0
printf ("% d", x);
}
return 0;
}
Solo lo spazio fa sembrare le cose divertenti, - diminuisce e> confronta.
|
L'utilizzo di -> ha rilevanza storica. Il decremento era (ed è ancora in alcuni casi) più veloce dell'incremento sull'architettura x86. L'uso di -> suggerisce che x sta andando a 0 e fa appello a quelli con background matematico.
|
mentre (x--> 0)
è come viene analizzato.
|
Assolutamente geek, ma userò questo:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
scrivi printf ("n è% d \ n", n) as (n -> 0);
return 0;
}
|
Un libro che ho letto (non ricordo correttamente quale libro) ha affermato: i compilatori cercano di analizzare le espressioni sul token più grande utilizzando la regola sinistra destra.
In questo caso, l'espressione:
x -> 0
Analizza i token più grandi:
gettone 1: x
gettone 2: -
token 3:>
gettone 4: 0
concludere: x--> 0
La stessa regola si applica a questa espressione:
a ----- b
Dopo l'analisi:
gettone 1: a
gettone 2: -
gettone 3: -
gettone 4: -
gettone 5: b
concludere: (a -) - - b
Spero che questo aiuti a capire l'espressione complicata ^^
|
Questo è esattamente lo stesso di
mentre (x--)
{
printf ("% d", x);
}
per numeri non negativi
|
Ad ogni modo, ora abbiamo un operatore "va a". "->" è facile da ricordare come una direzione, e "mentre x va a zero" è il significato-diritto.
Inoltre, è un po 'più efficiente di "for (x = 10; x> 0; x -)" su alcune piattaforme.
|
Questo codice prima confronta x e 0 e poi decrementa x. (Detto anche nella prima risposta: stai decrementando x e quindi confrontando x e 0 con l'operatore>.) Vedi l'output di questo codice:
9 8 7 6 5 4 3 2 1 0
Ora confrontiamo prima e poi decrementiamo vedendo 0 nell'output.
Se vogliamo prima decrementare e poi confrontare, usa questo codice:
#include 
int main (void)
{
int x = 10;
mentre (--x> 0) // x va a 0
{
printf ("% d", x);
}
return 0;
}
Quell'output è:
9 8 7 6 5 4 3 2 1
|
Il mio compilatore stamperà 9876543210 quando eseguo questo codice.
#include 
int main ()
{
int x = 10;
while (x -> 0) // x va a 0
{
std :: cout << x;
}
}
Come previsto. Il while (x--> 0) in realtà significa while (x> 0). La x-- post decrementa x.
mentre (x> 0)
{
X--;
std :: cout << x;
}
è un modo diverso di scrivere la stessa cosa.
Tuttavia è bello che l'originale assomigli a "mentre x va a 0".
|
Manca uno spazio tra - e>. x è post decrementato, cioè decrementato dopo aver verificato la condizione x> 0?.
|
- è l'operatore di decremento e> è l'operatore maggiore di.
I due operatori vengono applicati come uno solo come ->.
|
È una combinazione di due operatori. Primo: serve per decrementare il valore e> serve per verificare se il valore è maggiore dell'operando di destra.
#include 
int main ()
{
int x = 10;
mentre (x--> 0)
printf ("% d", x);
return 0;
}
L'output sarà:
9 8 7 6 5 4 3 2 1 0
|
In realtà, x sta decrementando e con quella condizione viene controllato. Non è ->, è (x--)> 0
Nota: il valore di x viene modificato dopo che la condizione è stata verificata, poiché è in decremento successivo. Possono verificarsi anche casi simili, ad esempio:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
C e C ++ obbediscono alla regola del "massimo munch". Allo stesso modo in cui a --- b viene tradotto in (a--) - b, nel tuo caso x -> 0 si traduce in (x -)> 0.
Ciò che la regola dice essenzialmente è che andando da sinistra a destra, le espressioni si formano prendendo il massimo di caratteri che formeranno un'espressione valida.
|
Perché tutte le complicazioni?
La semplice risposta alla domanda originale è semplicemente:
#include 
int main ()
{
int x = 10;
mentre (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Fa la stessa cosa. Non sto dicendo che dovresti farlo in questo modo, ma fa la stessa cosa e avrebbe risposto alla domanda in un post.
La x-- è solo una scorciatoia per quanto sopra e> è solo un normale operatore maggiore di. Nessun grande mistero!
Ci sono troppe persone che complicano le cose semplici al giorno d'oggi;)
|
Nel modo convenzionale definiremmo una condizione nella parentesi del ciclo while () e una condizione di terminazione all'interno delle parentesi graffe {}, ma -> le definisce entrambe contemporaneamente.
Per esempio:
int abc (void)
{
int a = 5
while ((a--)> 0) // Decrementa e confronta entrambi contemporaneamente
{
// Codice
}
}
Questo diminuisce a ed esegue il ciclo mentre a è maggiore di 0.
Convenzionalmente, sarebbe come:
int abc (void)
{
int a = 5;
while (a> 0)
{
un--;
// Codice
}
un--;
}
In entrambi i modi, facciamo la stessa cosa e raggiungiamo gli stessi obiettivi.
|
(x -> 0) significa (x--> 0).
È possibile utilizzare (x ->) Output: 9 8 7 6 5 4 3 2 1 0
Puoi usare (- x> 0) È medio (--x> 0) Output: 9 8 7 6 5 4 3 2 1
Puoi usare
(- \
\
x> 0)
Uscita: 9 8 7 6 5 4 3 2 1
Puoi usare
(\
\
x -> 0)
Uscita: 9 8 7 6 5 4 3 2 1 0
Puoi usare
(\
\
x -> 0
\
\
)
Uscita: 9 8 7 6 5 4 3 2 1 0
Puoi anche usare
(
X
->
)
Uscita: 9 8 7 6 5 4 3 2 1 0
Allo stesso modo, puoi provare molti metodi per eseguire questo comando con successo.
|
Ecco l'operatore unario di decremento di post.
while (x--> 0) // x va a 0
{
printf ("% d", x);
}
All'inizio, la condizione verrà valutata come
(x> 0) // 10> 0
Ora, poiché la condizione è vera, entrerà nel ciclo con un valore decrementato
x-- // x = 9
Ecco perché il primo valore stampato è 9
E così via. Nell'ultimo ciclo x = 1, quindi la condizione è vera. Come per l'operatore unario, il valore è cambiato ax = 0 al momento della stampa.
Ora, x = 0, che valuta la condizione (x> 0) come falsa e il ciclo while termina.
|
Questo -> non è affatto un operatore. Abbiamo un operatore come ->, ma non come ->. È solo un'interpretazione errata di while (x--> 0) che significa semplicemente che x ha l'operatore di post decremento e questo ciclo verrà eseguito fino a quando non sarà maggiore di zero.
Un altro modo semplice per scrivere questo codice sarebbe while (x--). Il ciclo while si interromperà ogni volta che ottiene una condizione falsa e qui c'è solo un caso, cioè 0. Quindi si fermerà quando il valore x viene decrementato a zero.
|
Domanda molto attiva. Guadagna 10 punti reputazione per rispondere a questa domanda. Il requisito di reputazione aiuta a proteggere questa domanda dallo spam e dalle attività di mancata risposta.
Non è la risposta che stai cercando? Sfoglia altre domande etichettate con operatori c ++ c conformità agli standard di formattazione del codice o poni la tua domanda.